//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Route53Domains service.
///
/// Amazon Route 53 API actions let you register domain names and perform related
/// 			operations.
public struct Route53Domains: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Route53Domains client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            amzTarget: "Route53Domains_v20140515",
            serviceName: "Route53Domains",
            serviceIdentifier: "route53domains",
            serviceProtocol: .json(version: "1.1"),
            apiVersion: "2014-05-15",
            endpoint: endpoint,
            errorType: Route53DomainsErrorType.self,
            xmlNamespace: "https://route53domains.amazonaws.com/doc/2014-05-15/",
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Accepts the transfer of a domain from another Amazon Web Services account to the
    /// 				currentAmazon Web Services account. You initiate a transfer between Amazon Web Services accounts using TransferDomainToAnotherAwsAccount. If you use the CLI command at accept-domain-transfer-from-another-aws-account, use JSON format as input
    /// 			instead of text because otherwise CLI will throw an error from domain
    /// 			transfer input that includes single quotes. Use either ListOperations or GetOperationDetail to determine whether the operation succeeded. GetOperationDetail provides additional information, for example,
    /// 				Domain Transfer from Aws Account 111122223333 has been cancelled.
    @Sendable
    @inlinable
    public func acceptDomainTransferFromAnotherAwsAccount(_ input: AcceptDomainTransferFromAnotherAwsAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AcceptDomainTransferFromAnotherAwsAccountResponse {
        try await self.client.execute(
            operation: "AcceptDomainTransferFromAnotherAwsAccount", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Accepts the transfer of a domain from another Amazon Web Services account to the
    /// 				currentAmazon Web Services account. You initiate a transfer between Amazon Web Services accounts using TransferDomainToAnotherAwsAccount. If you use the CLI command at accept-domain-transfer-from-another-aws-account, use JSON format as input
    /// 			instead of text because otherwise CLI will throw an error from domain
    /// 			transfer input that includes single quotes. Use either ListOperations or GetOperationDetail to determine whether the operation succeeded. GetOperationDetail provides additional information, for example,
    /// 				Domain Transfer from Aws Account 111122223333 has been cancelled.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain that was specified when another Amazon Web Services account
    ///   - password: The password that was returned by the TransferDomainToAnotherAwsAccount request.
    ///   - logger: Logger use during operation
    @inlinable
    public func acceptDomainTransferFromAnotherAwsAccount(
        domainName: String,
        password: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AcceptDomainTransferFromAnotherAwsAccountResponse {
        let input = AcceptDomainTransferFromAnotherAwsAccountRequest(
            domainName: domainName, 
            password: password
        )
        return try await self.acceptDomainTransferFromAnotherAwsAccount(input, logger: logger)
    }

    ///  Creates a delegation signer (DS) record in the registry zone for this domain
    /// 			name. Note that creating DS record at the registry impacts DNSSEC validation of your DNS
    /// 			records. This action may render your domain name unavailable on the internet if the
    /// 			steps are completed in the wrong order, or with incorrect timing. For more information
    /// 			about DNSSEC signing, see Configuring DNSSEC
    /// 				signing in the Route 53 developer
    /// 			guide.
    @Sendable
    @inlinable
    public func associateDelegationSignerToDomain(_ input: AssociateDelegationSignerToDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateDelegationSignerToDomainResponse {
        try await self.client.execute(
            operation: "AssociateDelegationSignerToDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a delegation signer (DS) record in the registry zone for this domain
    /// 			name. Note that creating DS record at the registry impacts DNSSEC validation of your DNS
    /// 			records. This action may render your domain name unavailable on the internet if the
    /// 			steps are completed in the wrong order, or with incorrect timing. For more information
    /// 			about DNSSEC signing, see Configuring DNSSEC
    /// 				signing in the Route 53 developer
    /// 			guide.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain.
    ///   - signingAttributes: The information about a key, including the algorithm, public key-value, and
    ///   - logger: Logger use during operation
    @inlinable
    public func associateDelegationSignerToDomain(
        domainName: String,
        signingAttributes: DnssecSigningAttributes,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateDelegationSignerToDomainResponse {
        let input = AssociateDelegationSignerToDomainRequest(
            domainName: domainName, 
            signingAttributes: signingAttributes
        )
        return try await self.associateDelegationSignerToDomain(input, logger: logger)
    }

    /// Cancels the transfer of a domain from the current Amazon Web Services account to
    /// 			another Amazon Web Services account. You initiate a transfer betweenAmazon Web Services accounts using TransferDomainToAnotherAwsAccount.   You must cancel the transfer before the other Amazon Web Services account accepts
    /// 				the transfer using AcceptDomainTransferFromAnotherAwsAccount.  Use either ListOperations or GetOperationDetail to determine whether the operation succeeded. GetOperationDetail provides additional information, for example,
    /// 				Domain Transfer from Aws Account 111122223333 has been cancelled.
    @Sendable
    @inlinable
    public func cancelDomainTransferToAnotherAwsAccount(_ input: CancelDomainTransferToAnotherAwsAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelDomainTransferToAnotherAwsAccountResponse {
        try await self.client.execute(
            operation: "CancelDomainTransferToAnotherAwsAccount", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels the transfer of a domain from the current Amazon Web Services account to
    /// 			another Amazon Web Services account. You initiate a transfer betweenAmazon Web Services accounts using TransferDomainToAnotherAwsAccount.   You must cancel the transfer before the other Amazon Web Services account accepts
    /// 				the transfer using AcceptDomainTransferFromAnotherAwsAccount.  Use either ListOperations or GetOperationDetail to determine whether the operation succeeded. GetOperationDetail provides additional information, for example,
    /// 				Domain Transfer from Aws Account 111122223333 has been cancelled.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain for which you want to cancel the transfer to another Amazon Web Services account.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelDomainTransferToAnotherAwsAccount(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelDomainTransferToAnotherAwsAccountResponse {
        let input = CancelDomainTransferToAnotherAwsAccountRequest(
            domainName: domainName
        )
        return try await self.cancelDomainTransferToAnotherAwsAccount(input, logger: logger)
    }

    /// This operation checks the availability of one domain name. Note that if the
    /// 			availability status of a domain is pending, you must submit another request to determine
    /// 			the availability of the domain name.
    @Sendable
    @inlinable
    public func checkDomainAvailability(_ input: CheckDomainAvailabilityRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CheckDomainAvailabilityResponse {
        try await self.client.execute(
            operation: "CheckDomainAvailability", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation checks the availability of one domain name. Note that if the
    /// 			availability status of a domain is pending, you must submit another request to determine
    /// 			the availability of the domain name.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain that you want to get availability for. The top-level domain
    ///   - idnLangCode: Reserved for future use.
    ///   - logger: Logger use during operation
    @inlinable
    public func checkDomainAvailability(
        domainName: String,
        idnLangCode: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CheckDomainAvailabilityResponse {
        let input = CheckDomainAvailabilityRequest(
            domainName: domainName, 
            idnLangCode: idnLangCode
        )
        return try await self.checkDomainAvailability(input, logger: logger)
    }

    /// Checks whether a domain name can be transferred to Amazon Route 53.
    @Sendable
    @inlinable
    public func checkDomainTransferability(_ input: CheckDomainTransferabilityRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CheckDomainTransferabilityResponse {
        try await self.client.execute(
            operation: "CheckDomainTransferability", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Checks whether a domain name can be transferred to Amazon Route 53.
    ///
    /// Parameters:
    ///   - authCode: If the registrar for the top-level domain (TLD) requires an authorization code to
    ///   - domainName: The name of the domain that you want to transfer to Route 53. The top-level domain
    ///   - logger: Logger use during operation
    @inlinable
    public func checkDomainTransferability(
        authCode: String? = nil,
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CheckDomainTransferabilityResponse {
        let input = CheckDomainTransferabilityRequest(
            authCode: authCode, 
            domainName: domainName
        )
        return try await self.checkDomainTransferability(input, logger: logger)
    }

    /// This operation deletes the specified domain. This action is permanent. For more
    /// 			information, see Deleting a domain name
    /// 				registration. To transfer the domain registration to another registrar, use the transfer process
    /// 			that’s provided by the registrar to which you want to transfer the registration.
    /// 			Otherwise, the following apply:   You can’t get a refund for the cost of a deleted domain registration.   The registry for the top-level domain might hold the domain name for a brief
    /// 					time before releasing it for other users to register (varies by registry).
    /// 				   When the registration has been deleted, we'll send you a confirmation to the
    /// 					registrant contact. The email will come from
    /// 						noreply@domainnameverification.net or
    /// 						noreply@registrar.amazon.com.
    @Sendable
    @inlinable
    public func deleteDomain(_ input: DeleteDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteDomainResponse {
        try await self.client.execute(
            operation: "DeleteDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation deletes the specified domain. This action is permanent. For more
    /// 			information, see Deleting a domain name
    /// 				registration. To transfer the domain registration to another registrar, use the transfer process
    /// 			that’s provided by the registrar to which you want to transfer the registration.
    /// 			Otherwise, the following apply:   You can’t get a refund for the cost of a deleted domain registration.   The registry for the top-level domain might hold the domain name for a brief
    /// 					time before releasing it for other users to register (varies by registry).
    /// 				   When the registration has been deleted, we'll send you a confirmation to the
    /// 					registrant contact. The email will come from
    /// 						noreply@domainnameverification.net or
    /// 						noreply@registrar.amazon.com.
    ///
    /// Parameters:
    ///   - domainName: Name of the domain to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDomain(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteDomainResponse {
        let input = DeleteDomainRequest(
            domainName: domainName
        )
        return try await self.deleteDomain(input, logger: logger)
    }

    /// This operation deletes the specified tags for a domain. All tag operations are eventually consistent; subsequent operations might not
    /// 			immediately represent all issued operations.
    @Sendable
    @inlinable
    public func deleteTagsForDomain(_ input: DeleteTagsForDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteTagsForDomainResponse {
        try await self.client.execute(
            operation: "DeleteTagsForDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation deletes the specified tags for a domain. All tag operations are eventually consistent; subsequent operations might not
    /// 			immediately represent all issued operations.
    ///
    /// Parameters:
    ///   - domainName: The domain for which you want to delete one or more tags.
    ///   - tagsToDelete: A list of tag keys to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteTagsForDomain(
        domainName: String,
        tagsToDelete: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteTagsForDomainResponse {
        let input = DeleteTagsForDomainRequest(
            domainName: domainName, 
            tagsToDelete: tagsToDelete
        )
        return try await self.deleteTagsForDomain(input, logger: logger)
    }

    /// This operation disables automatic renewal of domain registration for the specified
    /// 			domain.
    @Sendable
    @inlinable
    public func disableDomainAutoRenew(_ input: DisableDomainAutoRenewRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisableDomainAutoRenewResponse {
        try await self.client.execute(
            operation: "DisableDomainAutoRenew", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation disables automatic renewal of domain registration for the specified
    /// 			domain.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain that you want to disable automatic renewal for.
    ///   - logger: Logger use during operation
    @inlinable
    public func disableDomainAutoRenew(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisableDomainAutoRenewResponse {
        let input = DisableDomainAutoRenewRequest(
            domainName: domainName
        )
        return try await self.disableDomainAutoRenew(input, logger: logger)
    }

    /// This operation removes the transfer lock on the domain (specifically the
    /// 				clientTransferProhibited status) to allow domain transfers. We
    /// 			recommend you refrain from performing this action unless you intend to transfer the
    /// 			domain to a different registrar. Successful submission returns an operation ID that you
    /// 			can use to track the progress and completion of the action. If the request is not
    /// 			completed successfully, the domain registrant will be notified by email.
    @Sendable
    @inlinable
    public func disableDomainTransferLock(_ input: DisableDomainTransferLockRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisableDomainTransferLockResponse {
        try await self.client.execute(
            operation: "DisableDomainTransferLock", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation removes the transfer lock on the domain (specifically the
    /// 				clientTransferProhibited status) to allow domain transfers. We
    /// 			recommend you refrain from performing this action unless you intend to transfer the
    /// 			domain to a different registrar. Successful submission returns an operation ID that you
    /// 			can use to track the progress and completion of the action. If the request is not
    /// 			completed successfully, the domain registrant will be notified by email.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain that you want to remove the transfer lock for.
    ///   - logger: Logger use during operation
    @inlinable
    public func disableDomainTransferLock(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisableDomainTransferLockResponse {
        let input = DisableDomainTransferLockRequest(
            domainName: domainName
        )
        return try await self.disableDomainTransferLock(input, logger: logger)
    }

    /// Deletes a delegation signer (DS) record in the registry zone for this domain
    /// 			name.
    @Sendable
    @inlinable
    public func disassociateDelegationSignerFromDomain(_ input: DisassociateDelegationSignerFromDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateDelegationSignerFromDomainResponse {
        try await self.client.execute(
            operation: "DisassociateDelegationSignerFromDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a delegation signer (DS) record in the registry zone for this domain
    /// 			name.
    ///
    /// Parameters:
    ///   - domainName: Name of the domain.
    ///   - id: An internal identification number assigned to each DS record after it’s created. You
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateDelegationSignerFromDomain(
        domainName: String,
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateDelegationSignerFromDomainResponse {
        let input = DisassociateDelegationSignerFromDomainRequest(
            domainName: domainName, 
            id: id
        )
        return try await self.disassociateDelegationSignerFromDomain(input, logger: logger)
    }

    /// This operation configures Amazon Route 53 to automatically renew the specified domain
    /// 			before the domain registration expires. The cost of renewing your domain registration is
    /// 			billed to your Amazon Web Services account. The period during which you can renew a domain name varies by TLD. For a list of TLDs
    /// 			and their renewal policies, see Domains That You Can
    /// 				Register with Amazon Route 53 in the Amazon Route 53 Developer
    /// 				Guide. Route 53 requires that you renew before the end of the renewal
    /// 			period so we can complete processing before the deadline.
    @Sendable
    @inlinable
    public func enableDomainAutoRenew(_ input: EnableDomainAutoRenewRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> EnableDomainAutoRenewResponse {
        try await self.client.execute(
            operation: "EnableDomainAutoRenew", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation configures Amazon Route 53 to automatically renew the specified domain
    /// 			before the domain registration expires. The cost of renewing your domain registration is
    /// 			billed to your Amazon Web Services account. The period during which you can renew a domain name varies by TLD. For a list of TLDs
    /// 			and their renewal policies, see Domains That You Can
    /// 				Register with Amazon Route 53 in the Amazon Route 53 Developer
    /// 				Guide. Route 53 requires that you renew before the end of the renewal
    /// 			period so we can complete processing before the deadline.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain that you want to enable automatic renewal for.
    ///   - logger: Logger use during operation
    @inlinable
    public func enableDomainAutoRenew(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> EnableDomainAutoRenewResponse {
        let input = EnableDomainAutoRenewRequest(
            domainName: domainName
        )
        return try await self.enableDomainAutoRenew(input, logger: logger)
    }

    /// This operation sets the transfer lock on the domain (specifically the
    /// 				clientTransferProhibited status) to prevent domain transfers.
    /// 			Successful submission returns an operation ID that you can use to track the progress and
    /// 			completion of the action. If the request is not completed successfully, the domain
    /// 			registrant will be notified by email.
    @Sendable
    @inlinable
    public func enableDomainTransferLock(_ input: EnableDomainTransferLockRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> EnableDomainTransferLockResponse {
        try await self.client.execute(
            operation: "EnableDomainTransferLock", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation sets the transfer lock on the domain (specifically the
    /// 				clientTransferProhibited status) to prevent domain transfers.
    /// 			Successful submission returns an operation ID that you can use to track the progress and
    /// 			completion of the action. If the request is not completed successfully, the domain
    /// 			registrant will be notified by email.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain that you want to set the transfer lock for.
    ///   - logger: Logger use during operation
    @inlinable
    public func enableDomainTransferLock(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> EnableDomainTransferLockResponse {
        let input = EnableDomainTransferLockRequest(
            domainName: domainName
        )
        return try await self.enableDomainTransferLock(input, logger: logger)
    }

    /// For operations that require confirmation that the email address for the registrant
    /// 			contact is valid, such as registering a new domain, this operation returns information
    /// 			about whether the registrant contact has responded. If you want us to resend the email, use the
    /// 				ResendContactReachabilityEmail operation.
    @Sendable
    @inlinable
    public func getContactReachabilityStatus(_ input: GetContactReachabilityStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetContactReachabilityStatusResponse {
        try await self.client.execute(
            operation: "GetContactReachabilityStatus", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// For operations that require confirmation that the email address for the registrant
    /// 			contact is valid, such as registering a new domain, this operation returns information
    /// 			about whether the registrant contact has responded. If you want us to resend the email, use the
    /// 				ResendContactReachabilityEmail operation.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain for which you want to know whether the registrant contact has
    ///   - logger: Logger use during operation
    @inlinable
    public func getContactReachabilityStatus(
        domainName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetContactReachabilityStatusResponse {
        let input = GetContactReachabilityStatusRequest(
            domainName: domainName
        )
        return try await self.getContactReachabilityStatus(input, logger: logger)
    }

    /// This operation returns detailed information about a specified domain that is
    /// 			associated with the current Amazon Web Services account. Contact information for the
    /// 			domain is also returned as part of the output.
    @Sendable
    @inlinable
    public func getDomainDetail(_ input: GetDomainDetailRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDomainDetailResponse {
        try await self.client.execute(
            operation: "GetDomainDetail", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns detailed information about a specified domain that is
    /// 			associated with the current Amazon Web Services account. Contact information for the
    /// 			domain is also returned as part of the output.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain that you want to get detailed information about.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDomainDetail(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDomainDetailResponse {
        let input = GetDomainDetailRequest(
            domainName: domainName
        )
        return try await self.getDomainDetail(input, logger: logger)
    }

    /// The GetDomainSuggestions operation returns a list of suggested domain names.
    @Sendable
    @inlinable
    public func getDomainSuggestions(_ input: GetDomainSuggestionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDomainSuggestionsResponse {
        try await self.client.execute(
            operation: "GetDomainSuggestions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// The GetDomainSuggestions operation returns a list of suggested domain names.
    ///
    /// Parameters:
    ///   - domainName: A domain name that you want to use as the basis for a list of possible domain names.
    ///   - onlyAvailable: If OnlyAvailable is true, Route 53 returns only domain names
    ///   - suggestionCount: The number of suggested domain names that you want Route 53 to return. Specify a value
    ///   - logger: Logger use during operation
    @inlinable
    public func getDomainSuggestions(
        domainName: String,
        onlyAvailable: Bool,
        suggestionCount: Int = 0,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDomainSuggestionsResponse {
        let input = GetDomainSuggestionsRequest(
            domainName: domainName, 
            onlyAvailable: onlyAvailable, 
            suggestionCount: suggestionCount
        )
        return try await self.getDomainSuggestions(input, logger: logger)
    }

    /// This operation returns the current status of an operation that is not
    /// 			completed.
    @Sendable
    @inlinable
    public func getOperationDetail(_ input: GetOperationDetailRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOperationDetailResponse {
        try await self.client.execute(
            operation: "GetOperationDetail", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns the current status of an operation that is not
    /// 			completed.
    ///
    /// Parameters:
    ///   - operationId: The identifier for the operation for which you want to get the status. Route 53
    ///   - logger: Logger use during operation
    @inlinable
    public func getOperationDetail(
        operationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOperationDetailResponse {
        let input = GetOperationDetailRequest(
            operationId: operationId
        )
        return try await self.getOperationDetail(input, logger: logger)
    }

    /// This operation returns all the domain names registered with Amazon Route 53 for the
    /// 			current Amazon Web Services account if no filtering conditions are used.
    @Sendable
    @inlinable
    public func listDomains(_ input: ListDomainsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDomainsResponse {
        try await self.client.execute(
            operation: "ListDomains", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns all the domain names registered with Amazon Route 53 for the
    /// 			current Amazon Web Services account if no filtering conditions are used.
    ///
    /// Parameters:
    ///   - filterConditions: A complex type that contains information about the filters applied during the
    ///   - marker: For an initial request for a list of domains, omit this element. If the number of
    ///   - maxItems: Number of domains to be returned. Default: 20
    ///   - sortCondition: A complex type that contains information about the requested ordering of domains in
    ///   - logger: Logger use during operation
    @inlinable
    public func listDomains(
        filterConditions: [FilterCondition]? = nil,
        marker: String? = nil,
        maxItems: Int? = nil,
        sortCondition: SortCondition? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDomainsResponse {
        let input = ListDomainsRequest(
            filterConditions: filterConditions, 
            marker: marker, 
            maxItems: maxItems, 
            sortCondition: sortCondition
        )
        return try await self.listDomains(input, logger: logger)
    }

    /// Returns information about all of the operations that return an operation ID and that
    /// 			have ever been performed on domains that were registered by the current account.  This command runs only in the us-east-1 Region.
    @Sendable
    @inlinable
    public func listOperations(_ input: ListOperationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOperationsResponse {
        try await self.client.execute(
            operation: "ListOperations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about all of the operations that return an operation ID and that
    /// 			have ever been performed on domains that were registered by the current account.  This command runs only in the us-east-1 Region.
    ///
    /// Parameters:
    ///   - marker: For an initial request for a list of operations, omit this element. If the number of
    ///   - maxItems: Number of domains to be returned. Default: 20
    ///   - sortBy:  The sort type for returned values.
    ///   - sortOrder:  The sort order for returned values, either ascending or descending.
    ///   - status:  The status of the operations.
    ///   - submittedSince: An optional parameter that lets you get information about all the operations that you
    ///   - type:  An arrays of the domains operation types.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOperations(
        marker: String? = nil,
        maxItems: Int? = nil,
        sortBy: ListOperationsSortAttributeName? = nil,
        sortOrder: SortOrder? = nil,
        status: [OperationStatus]? = nil,
        submittedSince: Date? = nil,
        type: [OperationType]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOperationsResponse {
        let input = ListOperationsRequest(
            marker: marker, 
            maxItems: maxItems, 
            sortBy: sortBy, 
            sortOrder: sortOrder, 
            status: status, 
            submittedSince: submittedSince, 
            type: type
        )
        return try await self.listOperations(input, logger: logger)
    }

    /// Lists the following prices for either all the TLDs supported by Route 53, or
    /// 			the specified TLD:   Registration   Transfer   Owner change   Domain renewal   Domain restoration
    @Sendable
    @inlinable
    public func listPrices(_ input: ListPricesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPricesResponse {
        try await self.client.execute(
            operation: "ListPrices", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the following prices for either all the TLDs supported by Route 53, or
    /// 			the specified TLD:   Registration   Transfer   Owner change   Domain renewal   Domain restoration
    ///
    /// Parameters:
    ///   - marker: For an initial request for a list of prices, omit this element. If the number of
    ///   - maxItems: Number of Prices to be returned. Used only for all TLDs. If you specify a TLD, don't specify a
    ///   - tld: The TLD for which you want to receive the pricing information. For example.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPrices(
        marker: String? = nil,
        maxItems: Int? = nil,
        tld: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPricesResponse {
        let input = ListPricesRequest(
            marker: marker, 
            maxItems: maxItems, 
            tld: tld
        )
        return try await self.listPrices(input, logger: logger)
    }

    /// This operation returns all of the tags that are associated with the specified
    /// 			domain. All tag operations are eventually consistent; subsequent operations might not
    /// 			immediately represent all issued operations.
    @Sendable
    @inlinable
    public func listTagsForDomain(_ input: ListTagsForDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForDomainResponse {
        try await self.client.execute(
            operation: "ListTagsForDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns all of the tags that are associated with the specified
    /// 			domain. All tag operations are eventually consistent; subsequent operations might not
    /// 			immediately represent all issued operations.
    ///
    /// Parameters:
    ///   - domainName: The domain for which you want to get a list of tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForDomain(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForDomainResponse {
        let input = ListTagsForDomainRequest(
            domainName: domainName
        )
        return try await self.listTagsForDomain(input, logger: logger)
    }

    ///  Moves a domain from Amazon Web Services to another registrar.  Supported actions:   Changes the IPS tags of a .uk domain, and pushes it to transit. Transit means
    /// 					that the domain is ready to be transferred to another registrar.
    @Sendable
    @inlinable
    public func pushDomain(_ input: PushDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "PushDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Moves a domain from Amazon Web Services to another registrar.  Supported actions:   Changes the IPS tags of a .uk domain, and pushes it to transit. Transit means
    /// 					that the domain is ready to be transferred to another registrar.
    ///
    /// Parameters:
    ///   - domainName:  Name of the domain.
    ///   - target:  New IPS tag for the domain.
    ///   - logger: Logger use during operation
    @inlinable
    public func pushDomain(
        domainName: String,
        target: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = PushDomainRequest(
            domainName: domainName, 
            target: target
        )
        return try await self.pushDomain(input, logger: logger)
    }

    /// This operation registers a domain. For some top-level domains (TLDs), this operation
    /// 			requires extra parameters. When you register a domain, Amazon Route 53 does the following:   Creates a Route 53 hosted zone that has the same name as the domain. Route 53
    /// 					assigns four name servers to your hosted zone and automatically updates your
    /// 					domain registration with the names of these name servers.   Enables auto renew, so your domain registration will renew automatically each
    /// 					year. We'll notify you in advance of the renewal date so you can choose whether
    /// 					to renew the registration.   Optionally enables privacy protection, so WHOIS queries return contact for the registrar
    /// 					or the phrase "REDACTED FOR PRIVACY", or "On behalf of  owner."
    /// 					If you don't enable privacy protection, WHOIS queries return the information
    /// 					that you entered for the administrative, registrant, and technical
    /// 					contacts.  While some domains may allow different privacy settings per contact, we recommend
    /// 						specifying the same privacy setting for all contacts.    If registration is successful, returns an operation ID that you can use to
    /// 					track the progress and completion of the action. If the request is not completed
    /// 					successfully, the domain registrant is notified by email.   Charges your Amazon Web Services account an amount based on the top-level
    /// 					domain. For more information, see Amazon Route 53 Pricing.
    @Sendable
    @inlinable
    public func registerDomain(_ input: RegisterDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RegisterDomainResponse {
        try await self.client.execute(
            operation: "RegisterDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation registers a domain. For some top-level domains (TLDs), this operation
    /// 			requires extra parameters. When you register a domain, Amazon Route 53 does the following:   Creates a Route 53 hosted zone that has the same name as the domain. Route 53
    /// 					assigns four name servers to your hosted zone and automatically updates your
    /// 					domain registration with the names of these name servers.   Enables auto renew, so your domain registration will renew automatically each
    /// 					year. We'll notify you in advance of the renewal date so you can choose whether
    /// 					to renew the registration.   Optionally enables privacy protection, so WHOIS queries return contact for the registrar
    /// 					or the phrase "REDACTED FOR PRIVACY", or "On behalf of  owner."
    /// 					If you don't enable privacy protection, WHOIS queries return the information
    /// 					that you entered for the administrative, registrant, and technical
    /// 					contacts.  While some domains may allow different privacy settings per contact, we recommend
    /// 						specifying the same privacy setting for all contacts.    If registration is successful, returns an operation ID that you can use to
    /// 					track the progress and completion of the action. If the request is not completed
    /// 					successfully, the domain registrant is notified by email.   Charges your Amazon Web Services account an amount based on the top-level
    /// 					domain. For more information, see Amazon Route 53 Pricing.
    ///
    /// Parameters:
    ///   - adminContact: Provides detailed contact information. For information about the values that you
    ///   - autoRenew: Indicates whether the domain will be automatically renewed (true) or not
    ///   - billingContact: Provides detailed contact information. For information about the values that you
    ///   - domainName: The domain name that you want to register. The top-level domain (TLD), such as .com,
    ///   - durationInYears: The number of years that you want to register the domain for. Domains are registered
    ///   - idnLangCode: Reserved for future use.
    ///   - privacyProtectAdminContact: Whether you want to conceal contact information from WHOIS queries. If you specify
    ///   - privacyProtectBillingContact: Whether you want to conceal contact information from WHOIS queries. If you specify
    ///   - privacyProtectRegistrantContact: Whether you want to conceal contact information from WHOIS queries. If you specify
    ///   - privacyProtectTechContact: Whether you want to conceal contact information from WHOIS queries. If you specify
    ///   - registrantContact: Provides detailed contact information. For information about the values that you
    ///   - techContact: Provides detailed contact information. For information about the values that you
    ///   - logger: Logger use during operation
    @inlinable
    public func registerDomain(
        adminContact: ContactDetail,
        autoRenew: Bool? = nil,
        billingContact: ContactDetail? = nil,
        domainName: String,
        durationInYears: Int,
        idnLangCode: String? = nil,
        privacyProtectAdminContact: Bool? = nil,
        privacyProtectBillingContact: Bool? = nil,
        privacyProtectRegistrantContact: Bool? = nil,
        privacyProtectTechContact: Bool? = nil,
        registrantContact: ContactDetail,
        techContact: ContactDetail,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RegisterDomainResponse {
        let input = RegisterDomainRequest(
            adminContact: adminContact, 
            autoRenew: autoRenew, 
            billingContact: billingContact, 
            domainName: domainName, 
            durationInYears: durationInYears, 
            idnLangCode: idnLangCode, 
            privacyProtectAdminContact: privacyProtectAdminContact, 
            privacyProtectBillingContact: privacyProtectBillingContact, 
            privacyProtectRegistrantContact: privacyProtectRegistrantContact, 
            privacyProtectTechContact: privacyProtectTechContact, 
            registrantContact: registrantContact, 
            techContact: techContact
        )
        return try await self.registerDomain(input, logger: logger)
    }

    /// Rejects the transfer of a domain from another Amazon Web Services account to the
    /// 			current Amazon Web Services account. You initiate a transfer betweenAmazon Web Services accounts using TransferDomainToAnotherAwsAccount.  Use either ListOperations or GetOperationDetail to determine whether the operation succeeded. GetOperationDetail provides additional information, for example,
    /// 				Domain Transfer from Aws Account 111122223333 has been cancelled.
    @Sendable
    @inlinable
    public func rejectDomainTransferFromAnotherAwsAccount(_ input: RejectDomainTransferFromAnotherAwsAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RejectDomainTransferFromAnotherAwsAccountResponse {
        try await self.client.execute(
            operation: "RejectDomainTransferFromAnotherAwsAccount", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Rejects the transfer of a domain from another Amazon Web Services account to the
    /// 			current Amazon Web Services account. You initiate a transfer betweenAmazon Web Services accounts using TransferDomainToAnotherAwsAccount.  Use either ListOperations or GetOperationDetail to determine whether the operation succeeded. GetOperationDetail provides additional information, for example,
    /// 				Domain Transfer from Aws Account 111122223333 has been cancelled.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain that was specified when another Amazon Web Services account
    ///   - logger: Logger use during operation
    @inlinable
    public func rejectDomainTransferFromAnotherAwsAccount(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RejectDomainTransferFromAnotherAwsAccountResponse {
        let input = RejectDomainTransferFromAnotherAwsAccountRequest(
            domainName: domainName
        )
        return try await self.rejectDomainTransferFromAnotherAwsAccount(input, logger: logger)
    }

    /// This operation renews a domain for the specified number of years. The cost of renewing
    /// 			your domain is billed to your Amazon Web Services account. We recommend that you renew your domain several weeks before the expiration date. Some
    /// 			TLD registries delete domains before the expiration date if you haven't renewed far
    /// 			enough in advance. For more information about renewing domain registration, see Renewing
    /// 				Registration for a Domain in the Amazon Route 53 Developer
    /// 				Guide.
    @Sendable
    @inlinable
    public func renewDomain(_ input: RenewDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RenewDomainResponse {
        try await self.client.execute(
            operation: "RenewDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation renews a domain for the specified number of years. The cost of renewing
    /// 			your domain is billed to your Amazon Web Services account. We recommend that you renew your domain several weeks before the expiration date. Some
    /// 			TLD registries delete domains before the expiration date if you haven't renewed far
    /// 			enough in advance. For more information about renewing domain registration, see Renewing
    /// 				Registration for a Domain in the Amazon Route 53 Developer
    /// 				Guide.
    ///
    /// Parameters:
    ///   - currentExpiryYear: The year when the registration for the domain is set to expire. This value must match
    ///   - domainName: The name of the domain that you want to renew.
    ///   - durationInYears: The number of years that you want to renew the domain for. The maximum number of years
    ///   - logger: Logger use during operation
    @inlinable
    public func renewDomain(
        currentExpiryYear: Int = 0,
        domainName: String,
        durationInYears: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RenewDomainResponse {
        let input = RenewDomainRequest(
            currentExpiryYear: currentExpiryYear, 
            domainName: domainName, 
            durationInYears: durationInYears
        )
        return try await self.renewDomain(input, logger: logger)
    }

    /// For operations that require confirmation that the email address for the registrant
    /// 			contact is valid, such as registering a new domain, this operation resends the
    /// 			confirmation email to the current email address for the registrant contact.
    @Sendable
    @inlinable
    public func resendContactReachabilityEmail(_ input: ResendContactReachabilityEmailRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ResendContactReachabilityEmailResponse {
        try await self.client.execute(
            operation: "ResendContactReachabilityEmail", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// For operations that require confirmation that the email address for the registrant
    /// 			contact is valid, such as registering a new domain, this operation resends the
    /// 			confirmation email to the current email address for the registrant contact.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain for which you want Route 53 to resend a confirmation email to
    ///   - logger: Logger use during operation
    @inlinable
    public func resendContactReachabilityEmail(
        domainName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ResendContactReachabilityEmailResponse {
        let input = ResendContactReachabilityEmailRequest(
            domainName: domainName
        )
        return try await self.resendContactReachabilityEmail(input, logger: logger)
    }

    ///  Resend the form of authorization email for this operation.
    @Sendable
    @inlinable
    public func resendOperationAuthorization(_ input: ResendOperationAuthorizationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "ResendOperationAuthorization", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Resend the form of authorization email for this operation.
    ///
    /// Parameters:
    ///   - operationId:  Operation ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func resendOperationAuthorization(
        operationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = ResendOperationAuthorizationRequest(
            operationId: operationId
        )
        return try await self.resendOperationAuthorization(input, logger: logger)
    }

    /// This operation returns the authorization code for the domain. To transfer a domain to
    /// 			another registrar, you provide this value to the new registrar.
    @Sendable
    @inlinable
    public func retrieveDomainAuthCode(_ input: RetrieveDomainAuthCodeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RetrieveDomainAuthCodeResponse {
        try await self.client.execute(
            operation: "RetrieveDomainAuthCode", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation returns the authorization code for the domain. To transfer a domain to
    /// 			another registrar, you provide this value to the new registrar.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain that you want to get an authorization code for.
    ///   - logger: Logger use during operation
    @inlinable
    public func retrieveDomainAuthCode(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RetrieveDomainAuthCodeResponse {
        let input = RetrieveDomainAuthCodeRequest(
            domainName: domainName
        )
        return try await self.retrieveDomainAuthCode(input, logger: logger)
    }

    /// Transfers a domain from another registrar to Amazon Route 53.  For more information about transferring domains, see the following topics:   For transfer requirements, a detailed procedure, and information about viewing
    /// 					the status of a domain that you're transferring to Route 53, see Transferring Registration for a Domain to Amazon Route 53 in the
    /// 						Amazon Route 53 Developer Guide.   For information about how to transfer a domain from one Amazon Web Services account to another, see TransferDomainToAnotherAwsAccount.    For information about how to transfer a domain to another domain registrar,
    /// 					see Transferring a Domain from Amazon Route 53 to Another Registrar in
    /// 					the Amazon Route 53 Developer Guide.    During the transfer of any country code top-level domains (ccTLDs) to Route 53, except for .cc and .tv,
    /// 			updates to the owner contact are ignored and the owner contact data from the registry is used.
    /// 			You can
    /// 			update the owner contact after the transfer is complete. For more information, see
    /// 			UpdateDomainContact.  If the registrar for your domain is also the DNS service provider for the domain, we
    /// 			highly recommend that you transfer your DNS service to Route 53 or to another DNS
    /// 			service provider before you transfer your registration. Some registrars provide free DNS
    /// 			service when you purchase a domain registration. When you transfer the registration, the
    /// 			previous registrar will not renew your domain registration and could end your DNS
    /// 			service at any time.  If the registrar for your domain is also the DNS service provider for the domain
    /// 				and you don't transfer DNS service to another provider, your website, email, and the
    /// 				web applications associated with the domain might become unavailable.  If the transfer is successful, this method returns an operation ID that you can use to
    /// 			track the progress and completion of the action. If the transfer doesn't complete
    /// 			successfully, the domain registrant will be notified by email.
    @Sendable
    @inlinable
    public func transferDomain(_ input: TransferDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TransferDomainResponse {
        try await self.client.execute(
            operation: "TransferDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Transfers a domain from another registrar to Amazon Route 53.  For more information about transferring domains, see the following topics:   For transfer requirements, a detailed procedure, and information about viewing
    /// 					the status of a domain that you're transferring to Route 53, see Transferring Registration for a Domain to Amazon Route 53 in the
    /// 						Amazon Route 53 Developer Guide.   For information about how to transfer a domain from one Amazon Web Services account to another, see TransferDomainToAnotherAwsAccount.    For information about how to transfer a domain to another domain registrar,
    /// 					see Transferring a Domain from Amazon Route 53 to Another Registrar in
    /// 					the Amazon Route 53 Developer Guide.    During the transfer of any country code top-level domains (ccTLDs) to Route 53, except for .cc and .tv,
    /// 			updates to the owner contact are ignored and the owner contact data from the registry is used.
    /// 			You can
    /// 			update the owner contact after the transfer is complete. For more information, see
    /// 			UpdateDomainContact.  If the registrar for your domain is also the DNS service provider for the domain, we
    /// 			highly recommend that you transfer your DNS service to Route 53 or to another DNS
    /// 			service provider before you transfer your registration. Some registrars provide free DNS
    /// 			service when you purchase a domain registration. When you transfer the registration, the
    /// 			previous registrar will not renew your domain registration and could end your DNS
    /// 			service at any time.  If the registrar for your domain is also the DNS service provider for the domain
    /// 				and you don't transfer DNS service to another provider, your website, email, and the
    /// 				web applications associated with the domain might become unavailable.  If the transfer is successful, this method returns an operation ID that you can use to
    /// 			track the progress and completion of the action. If the transfer doesn't complete
    /// 			successfully, the domain registrant will be notified by email.
    ///
    /// Parameters:
    ///   - adminContact: Provides detailed contact information.
    ///   - authCode: The authorization code for the domain. You get this value from the current
    ///   - autoRenew: Indicates whether the domain will be automatically renewed (true) or not (false). Auto
    ///   - billingContact: Provides detailed contact information.
    ///   - domainName: The name of the domain that you want to transfer to Route 53. The top-level domain
    ///   - durationInYears: The number of years that you want to register the domain for. Domains are registered
    ///   - idnLangCode: Reserved for future use.
    ///   - nameservers: Contains details for the host and glue IP addresses.
    ///   - privacyProtectAdminContact: Whether you want to conceal contact information from WHOIS queries. If you specify
    ///   - privacyProtectBillingContact: 			Whether you want to conceal contact information from WHOIS queries. If you specify
    ///   - privacyProtectRegistrantContact: Whether you want to conceal contact information from WHOIS queries. If you specify
    ///   - privacyProtectTechContact: Whether you want to conceal contact information from WHOIS queries. If you specify
    ///   - registrantContact: Provides detailed contact information.
    ///   - techContact: Provides detailed contact information.
    ///   - logger: Logger use during operation
    @inlinable
    public func transferDomain(
        adminContact: ContactDetail,
        authCode: String? = nil,
        autoRenew: Bool? = nil,
        billingContact: ContactDetail? = nil,
        domainName: String,
        durationInYears: Int,
        idnLangCode: String? = nil,
        nameservers: [Nameserver]? = nil,
        privacyProtectAdminContact: Bool? = nil,
        privacyProtectBillingContact: Bool? = nil,
        privacyProtectRegistrantContact: Bool? = nil,
        privacyProtectTechContact: Bool? = nil,
        registrantContact: ContactDetail,
        techContact: ContactDetail,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TransferDomainResponse {
        let input = TransferDomainRequest(
            adminContact: adminContact, 
            authCode: authCode, 
            autoRenew: autoRenew, 
            billingContact: billingContact, 
            domainName: domainName, 
            durationInYears: durationInYears, 
            idnLangCode: idnLangCode, 
            nameservers: nameservers, 
            privacyProtectAdminContact: privacyProtectAdminContact, 
            privacyProtectBillingContact: privacyProtectBillingContact, 
            privacyProtectRegistrantContact: privacyProtectRegistrantContact, 
            privacyProtectTechContact: privacyProtectTechContact, 
            registrantContact: registrantContact, 
            techContact: techContact
        )
        return try await self.transferDomain(input, logger: logger)
    }

    /// Transfers a domain from the current Amazon Web Services account to another Amazon Web Services account. Note the following:   The Amazon Web Services account that you're transferring the domain to must
    /// 					accept the transfer. If the other account doesn't accept the transfer within 3
    /// 					days, we cancel the transfer. See AcceptDomainTransferFromAnotherAwsAccount.    You can cancel the transfer before the other account accepts it. See CancelDomainTransferToAnotherAwsAccount.    The other account can reject the transfer. See RejectDomainTransferFromAnotherAwsAccount.     When you transfer a domain from one Amazon Web Services account to another, Route
    /// 				53 doesn't transfer the hosted zone that is associated with the domain. DNS
    /// 				resolution isn't affected if the domain and the hosted zone are owned by separate
    /// 				accounts, so transferring the hosted zone is optional. For information about
    /// 				transferring the hosted zone to another Amazon Web Services account, see Migrating a
    /// 					Hosted Zone to a Different Amazon Web Services Account in the
    /// 					Amazon Route 53 Developer Guide.  Use either ListOperations or GetOperationDetail to determine whether the operation succeeded. GetOperationDetail provides additional information, for example,
    /// 				Domain Transfer from Aws Account 111122223333 has been cancelled.
    @Sendable
    @inlinable
    public func transferDomainToAnotherAwsAccount(_ input: TransferDomainToAnotherAwsAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TransferDomainToAnotherAwsAccountResponse {
        try await self.client.execute(
            operation: "TransferDomainToAnotherAwsAccount", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Transfers a domain from the current Amazon Web Services account to another Amazon Web Services account. Note the following:   The Amazon Web Services account that you're transferring the domain to must
    /// 					accept the transfer. If the other account doesn't accept the transfer within 3
    /// 					days, we cancel the transfer. See AcceptDomainTransferFromAnotherAwsAccount.    You can cancel the transfer before the other account accepts it. See CancelDomainTransferToAnotherAwsAccount.    The other account can reject the transfer. See RejectDomainTransferFromAnotherAwsAccount.     When you transfer a domain from one Amazon Web Services account to another, Route
    /// 				53 doesn't transfer the hosted zone that is associated with the domain. DNS
    /// 				resolution isn't affected if the domain and the hosted zone are owned by separate
    /// 				accounts, so transferring the hosted zone is optional. For information about
    /// 				transferring the hosted zone to another Amazon Web Services account, see Migrating a
    /// 					Hosted Zone to a Different Amazon Web Services Account in the
    /// 					Amazon Route 53 Developer Guide.  Use either ListOperations or GetOperationDetail to determine whether the operation succeeded. GetOperationDetail provides additional information, for example,
    /// 				Domain Transfer from Aws Account 111122223333 has been cancelled.
    ///
    /// Parameters:
    ///   - accountId: The account ID of the Amazon Web Services account that you want to transfer the domain
    ///   - domainName: The name of the domain that you want to transfer from the current Amazon Web Services account to another account.
    ///   - logger: Logger use during operation
    @inlinable
    public func transferDomainToAnotherAwsAccount(
        accountId: String,
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TransferDomainToAnotherAwsAccountResponse {
        let input = TransferDomainToAnotherAwsAccountRequest(
            accountId: accountId, 
            domainName: domainName
        )
        return try await self.transferDomainToAnotherAwsAccount(input, logger: logger)
    }

    /// This operation updates the contact information for a particular domain. You must
    /// 			specify information for at least one contact: registrant, administrator, or
    /// 			technical. If the update is successful, this method returns an operation ID that you can use to
    /// 			track the progress and completion of the operation. If the request is not completed
    /// 			successfully, the domain registrant will be notified by email.
    @Sendable
    @inlinable
    public func updateDomainContact(_ input: UpdateDomainContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDomainContactResponse {
        try await self.client.execute(
            operation: "UpdateDomainContact", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation updates the contact information for a particular domain. You must
    /// 			specify information for at least one contact: registrant, administrator, or
    /// 			technical. If the update is successful, this method returns an operation ID that you can use to
    /// 			track the progress and completion of the operation. If the request is not completed
    /// 			successfully, the domain registrant will be notified by email.
    ///
    /// Parameters:
    ///   - adminContact: Provides detailed contact information.
    ///   - billingContact: Provides detailed contact information.
    ///   - consent:  Customer's consent for the owner change request. Required if the domain is not free (consent price is more than $0.00).
    ///   - domainName: The name of the domain that you want to update contact information for.
    ///   - registrantContact: Provides detailed contact information.
    ///   - techContact: Provides detailed contact information.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDomainContact(
        adminContact: ContactDetail? = nil,
        billingContact: ContactDetail? = nil,
        consent: Consent? = nil,
        domainName: String,
        registrantContact: ContactDetail? = nil,
        techContact: ContactDetail? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDomainContactResponse {
        let input = UpdateDomainContactRequest(
            adminContact: adminContact, 
            billingContact: billingContact, 
            consent: consent, 
            domainName: domainName, 
            registrantContact: registrantContact, 
            techContact: techContact
        )
        return try await self.updateDomainContact(input, logger: logger)
    }

    /// This operation updates the specified domain contact's privacy setting. When privacy
    /// 			protection is enabled, your contact information is replaced with contact information for
    /// 			the registrar or with the phrase "REDACTED FOR PRIVACY", or "On behalf of  owner."  While some domains may allow different privacy settings per contact, we recommend
    /// 				specifying the same privacy setting for all contacts.  This operation affects only the contact information for the specified contact type
    /// 			(administrative, registrant, or technical). If the request succeeds, Amazon Route 53
    /// 			returns an operation ID that you can use with GetOperationDetail to track the progress and completion of the action. If
    /// 			the request doesn't complete successfully, the domain registrant will be notified by
    /// 			email.  By disabling the privacy service via API, you consent to the publication of the
    /// 				contact information provided for this domain via the public WHOIS database. You
    /// 				certify that you are the registrant of this domain name and have the authority to
    /// 				make this decision. You may withdraw your consent at any time by enabling privacy
    /// 				protection using either UpdateDomainContactPrivacy or the Route 53
    /// 				console. Enabling privacy protection removes the contact information provided for
    /// 				this domain from the WHOIS database. For more information on our privacy practices,
    /// 				see https://aws.amazon.com/privacy/.
    @Sendable
    @inlinable
    public func updateDomainContactPrivacy(_ input: UpdateDomainContactPrivacyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDomainContactPrivacyResponse {
        try await self.client.execute(
            operation: "UpdateDomainContactPrivacy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation updates the specified domain contact's privacy setting. When privacy
    /// 			protection is enabled, your contact information is replaced with contact information for
    /// 			the registrar or with the phrase "REDACTED FOR PRIVACY", or "On behalf of  owner."  While some domains may allow different privacy settings per contact, we recommend
    /// 				specifying the same privacy setting for all contacts.  This operation affects only the contact information for the specified contact type
    /// 			(administrative, registrant, or technical). If the request succeeds, Amazon Route 53
    /// 			returns an operation ID that you can use with GetOperationDetail to track the progress and completion of the action. If
    /// 			the request doesn't complete successfully, the domain registrant will be notified by
    /// 			email.  By disabling the privacy service via API, you consent to the publication of the
    /// 				contact information provided for this domain via the public WHOIS database. You
    /// 				certify that you are the registrant of this domain name and have the authority to
    /// 				make this decision. You may withdraw your consent at any time by enabling privacy
    /// 				protection using either UpdateDomainContactPrivacy or the Route 53
    /// 				console. Enabling privacy protection removes the contact information provided for
    /// 				this domain from the WHOIS database. For more information on our privacy practices,
    /// 				see https://aws.amazon.com/privacy/.
    ///
    /// Parameters:
    ///   - adminPrivacy: Whether you want to conceal contact information from WHOIS queries. If you specify
    ///   - billingPrivacy: 			Whether you want to conceal contact information from WHOIS queries. If you specify
    ///   - domainName: The name of the domain that you want to update the privacy setting for.
    ///   - registrantPrivacy: Whether you want to conceal contact information from WHOIS queries. If you specify
    ///   - techPrivacy: Whether you want to conceal contact information from WHOIS queries. If you specify
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDomainContactPrivacy(
        adminPrivacy: Bool? = nil,
        billingPrivacy: Bool? = nil,
        domainName: String,
        registrantPrivacy: Bool? = nil,
        techPrivacy: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDomainContactPrivacyResponse {
        let input = UpdateDomainContactPrivacyRequest(
            adminPrivacy: adminPrivacy, 
            billingPrivacy: billingPrivacy, 
            domainName: domainName, 
            registrantPrivacy: registrantPrivacy, 
            techPrivacy: techPrivacy
        )
        return try await self.updateDomainContactPrivacy(input, logger: logger)
    }

    /// This operation replaces the current set of name servers for the domain with the
    /// 			specified set of name servers. If you use Amazon Route 53 as your DNS service, specify
    /// 			the four name servers in the delegation set for the hosted zone for the domain. If successful, this operation returns an operation ID that you can use to track the
    /// 			progress and completion of the action. If the request is not completed successfully, the
    /// 			domain registrant will be notified by email.
    @Sendable
    @inlinable
    public func updateDomainNameservers(_ input: UpdateDomainNameserversRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDomainNameserversResponse {
        try await self.client.execute(
            operation: "UpdateDomainNameservers", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation replaces the current set of name servers for the domain with the
    /// 			specified set of name servers. If you use Amazon Route 53 as your DNS service, specify
    /// 			the four name servers in the delegation set for the hosted zone for the domain. If successful, this operation returns an operation ID that you can use to track the
    /// 			progress and completion of the action. If the request is not completed successfully, the
    /// 			domain registrant will be notified by email.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain that you want to change name servers for.
    ///   - nameservers: A list of new name servers for the domain.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDomainNameservers(
        domainName: String,
        nameservers: [Nameserver],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDomainNameserversResponse {
        let input = UpdateDomainNameserversRequest(
            domainName: domainName, 
            nameservers: nameservers
        )
        return try await self.updateDomainNameservers(input, logger: logger)
    }

    /// This operation adds or updates tags for a specified domain. All tag operations are eventually consistent; subsequent operations might not
    /// 			immediately represent all issued operations.
    @Sendable
    @inlinable
    public func updateTagsForDomain(_ input: UpdateTagsForDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateTagsForDomainResponse {
        try await self.client.execute(
            operation: "UpdateTagsForDomain", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This operation adds or updates tags for a specified domain. All tag operations are eventually consistent; subsequent operations might not
    /// 			immediately represent all issued operations.
    ///
    /// Parameters:
    ///   - domainName: The domain for which you want to add or update tags.
    ///   - tagsToUpdate: A list of the tag keys and values that you want to add or update. If you specify a key
    ///   - logger: Logger use during operation
    @inlinable
    public func updateTagsForDomain(
        domainName: String,
        tagsToUpdate: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateTagsForDomainResponse {
        let input = UpdateTagsForDomainRequest(
            domainName: domainName, 
            tagsToUpdate: tagsToUpdate
        )
        return try await self.updateTagsForDomain(input, logger: logger)
    }

    /// Returns all the domain-related billing records for the current Amazon Web Services account for a specified period
    @Sendable
    @inlinable
    public func viewBilling(_ input: ViewBillingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ViewBillingResponse {
        try await self.client.execute(
            operation: "ViewBilling", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns all the domain-related billing records for the current Amazon Web Services account for a specified period
    ///
    /// Parameters:
    ///   - end: The end date and time for the time period for which you want a list of billing
    ///   - marker: For an initial request for a list of billing records, omit this element. If the number
    ///   - maxItems: The number of billing records to be returned. Default: 20
    ///   - start: The beginning date and time for the time period for which you want a list of billing
    ///   - logger: Logger use during operation
    @inlinable
    public func viewBilling(
        end: Date? = nil,
        marker: String? = nil,
        maxItems: Int? = nil,
        start: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ViewBillingResponse {
        let input = ViewBillingRequest(
            end: end, 
            marker: marker, 
            maxItems: maxItems, 
            start: start
        )
        return try await self.viewBilling(input, logger: logger)
    }
}

extension Route53Domains {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Route53Domains, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Route53Domains {
    /// Return PaginatorSequence for operation ``listDomains(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDomainsPaginator(
        _ input: ListDomainsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDomainsRequest, ListDomainsResponse> {
        return .init(
            input: input,
            command: self.listDomains,
            inputKey: \ListDomainsRequest.marker,
            outputKey: \ListDomainsResponse.nextPageMarker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDomains(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterConditions: A complex type that contains information about the filters applied during the
    ///   - maxItems: Number of domains to be returned. Default: 20
    ///   - sortCondition: A complex type that contains information about the requested ordering of domains in
    ///   - logger: Logger used for logging
    @inlinable
    public func listDomainsPaginator(
        filterConditions: [FilterCondition]? = nil,
        maxItems: Int? = nil,
        sortCondition: SortCondition? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDomainsRequest, ListDomainsResponse> {
        let input = ListDomainsRequest(
            filterConditions: filterConditions, 
            maxItems: maxItems, 
            sortCondition: sortCondition
        )
        return self.listDomainsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOperations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOperationsPaginator(
        _ input: ListOperationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOperationsRequest, ListOperationsResponse> {
        return .init(
            input: input,
            command: self.listOperations,
            inputKey: \ListOperationsRequest.marker,
            outputKey: \ListOperationsResponse.nextPageMarker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOperations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxItems: Number of domains to be returned. Default: 20
    ///   - sortBy:  The sort type for returned values.
    ///   - sortOrder:  The sort order for returned values, either ascending or descending.
    ///   - status:  The status of the operations.
    ///   - submittedSince: An optional parameter that lets you get information about all the operations that you
    ///   - type:  An arrays of the domains operation types.
    ///   - logger: Logger used for logging
    @inlinable
    public func listOperationsPaginator(
        maxItems: Int? = nil,
        sortBy: ListOperationsSortAttributeName? = nil,
        sortOrder: SortOrder? = nil,
        status: [OperationStatus]? = nil,
        submittedSince: Date? = nil,
        type: [OperationType]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOperationsRequest, ListOperationsResponse> {
        let input = ListOperationsRequest(
            maxItems: maxItems, 
            sortBy: sortBy, 
            sortOrder: sortOrder, 
            status: status, 
            submittedSince: submittedSince, 
            type: type
        )
        return self.listOperationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPrices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPricesPaginator(
        _ input: ListPricesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPricesRequest, ListPricesResponse> {
        return .init(
            input: input,
            command: self.listPrices,
            inputKey: \ListPricesRequest.marker,
            outputKey: \ListPricesResponse.nextPageMarker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPrices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxItems: Number of Prices to be returned. Used only for all TLDs. If you specify a TLD, don't specify a
    ///   - tld: The TLD for which you want to receive the pricing information. For example.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPricesPaginator(
        maxItems: Int? = nil,
        tld: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPricesRequest, ListPricesResponse> {
        let input = ListPricesRequest(
            maxItems: maxItems, 
            tld: tld
        )
        return self.listPricesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``viewBilling(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func viewBillingPaginator(
        _ input: ViewBillingRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ViewBillingRequest, ViewBillingResponse> {
        return .init(
            input: input,
            command: self.viewBilling,
            inputKey: \ViewBillingRequest.marker,
            outputKey: \ViewBillingResponse.nextPageMarker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``viewBilling(_:logger:)``.
    ///
    /// - Parameters:
    ///   - end: The end date and time for the time period for which you want a list of billing
    ///   - maxItems: The number of billing records to be returned. Default: 20
    ///   - start: The beginning date and time for the time period for which you want a list of billing
    ///   - logger: Logger used for logging
    @inlinable
    public func viewBillingPaginator(
        end: Date? = nil,
        maxItems: Int? = nil,
        start: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ViewBillingRequest, ViewBillingResponse> {
        let input = ViewBillingRequest(
            end: end, 
            maxItems: maxItems, 
            start: start
        )
        return self.viewBillingPaginator(input, logger: logger)
    }
}

extension Route53Domains.ListDomainsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53Domains.ListDomainsRequest {
        return .init(
            filterConditions: self.filterConditions,
            marker: token,
            maxItems: self.maxItems,
            sortCondition: self.sortCondition
        )
    }
}

extension Route53Domains.ListOperationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53Domains.ListOperationsRequest {
        return .init(
            marker: token,
            maxItems: self.maxItems,
            sortBy: self.sortBy,
            sortOrder: self.sortOrder,
            status: self.status,
            submittedSince: self.submittedSince,
            type: self.type
        )
    }
}

extension Route53Domains.ListPricesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53Domains.ListPricesRequest {
        return .init(
            marker: token,
            maxItems: self.maxItems,
            tld: self.tld
        )
    }
}

extension Route53Domains.ViewBillingRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Route53Domains.ViewBillingRequest {
        return .init(
            end: self.end,
            marker: token,
            maxItems: self.maxItems,
            start: self.start
        )
    }
}
